class StringUtils {
    static RemoveMask(str: string): string {
        var numeros = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
        var result: string = '';
        for (var i = 0; i < str.length; i++) {
            if (numeros.indexOf(str.charAt(i)) >= 0) {
                result += str.charAt(i);
            }
        }
        return result;
    }

    static Reverse(str: string): string {
        var result = '';
        for (var i = str.length - 1; i >= 0; i--) {
            result += str.charAt(i);
        }
        return result;
    }
}

interface IValidadorIE {
    Validar(ie: string): bool;
}

class ValidadorIEAC implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var pesoAlterado = false;
        for (var alg = 0, peso = algarismosPrincipais.length - 7; alg < algarismosPrincipais.length; alg++, peso--) {
            if (!pesoAlterado && peso < 2) {
                pesoAlterado = true;
                peso = 9;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = 11 - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 13) {
            return false;
        }
        if (ie.substr(0, 2) != '01') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 11);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var digito2 = this.ObterDigitoVerificador(algarismosPrincipais + digito1);

        var resultado = algarismosPrincipais + digito1 + digito2;

        var ok = resultado == ie;
        return ok;
    }
}


class ValidadorIEAL implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var pesoAlterado = false;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        soma *= 10;
        var resto = soma - (Math.floor(soma / 11) * 11);

        var digito = resto;



        if (resto > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '24') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);

        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}


// AMAPA
class ValidadorIEAP implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var valorIE: number = parseInt(algarismosPrincipais);
        var p = 0, d = 0;
        if (valorIE >= 3000001 && valorIE <= 3017000) {
            p = 5;
            d = 0;
        } else if (valorIE >= 3017001 && valorIE <= 3019022) {
            p = 9;
            d = 1;
        }

        var soma = p;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = 11 - resto;
        if (digito == 10) {
            digito = 0;
        } else if (digito > 10) {
            digito = d;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '03') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);

        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// AMAZONAS
class ValidadorIEAM implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var digito = 0;
        if (soma < 11) {
            digito = 11 - soma;
        } else {
            var resto = soma % 11;
            if (resto <= 1) {
                digito = 0;
            } else {
                digito = 11 - resto;
            }
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);

        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}


// BAHIA
class ValidadorIEBA implements IValidadorIE {
    ObterDigitoVerificador8(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;        
        if (['0', '1', '2', '3', '4', '5', '8'].indexOf(algarismosPrincipais.charAt(0)) >= 0) {
            modulo = 10;
        } 
        
        for (var alg = 0, peso = algarismosPrincipais.length + 1; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    ObterDigitoVerificador9(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;        
        if (['0', '1', '2', '3', '4', '5', '8'].indexOf(
            algarismosPrincipais.charAt(1)) >= 0) {
            modulo = 10;
        }
        
        for (var alg = 0, peso = algarismosPrincipais.length + 1; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;        
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {   
        debugger;     
        if (ie.length < 8 || ie.length > 9) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, ie.length - 2);
        var digito2: string;
        var digito1: string;
        if (ie.length == 8) {
            digito2 = this.ObterDigitoVerificador8(algarismosPrincipais);
            digito1 = this.ObterDigitoVerificador8(algarismosPrincipais + digito2);
        } else {
            digito2 = this.ObterDigitoVerificador9(algarismosPrincipais);
            digito1 = this.ObterDigitoVerificador9(algarismosPrincipais + digito2);
        }       
        var resultado = algarismosPrincipais + digito1 + digito2;

        var ok = resultado == ie;
        return ok;
    }
}

// CEARA
class ValidadorIECE implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }
}

// DISTRITO FEDERAL
class ValidadorIEDF implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var pesoAlterado = false;
        var modulo = 11;
        for (var alg = 0, peso = algarismosPrincipais.length - 7; alg < algarismosPrincipais.length; alg++, peso--) {
            if (!pesoAlterado && peso < 2) {
                pesoAlterado = true;
                peso = 9;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = 11 - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 13) {
            return false;
        }
        if (ie.substr(0, 2) != '07') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 11);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var digito2 = this.ObterDigitoVerificador(algarismosPrincipais + digito1);
        var resultado = algarismosPrincipais + digito1 + digito2;
        var ok = resultado == ie;
        return ok;
    }
}

// ESPIRITO SANTO
class ValidadorIEES implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = resto < 2 ? 0 : 11 - resto;
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }
}

// GOIAS
class ValidadorIEGO implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = 0;
        if (resto == 0) {
            digito = 0;
        } else if (resto == 1) {
            var valorAlgarismos = parseInt(algarismosPrincipais);
            if (valorAlgarismos >= 10103105 ||
                valorAlgarismos <= 10119997) {
                digito = 1;
            } else {
                digito = 0;
            }
        } else {
            digito = 11 - resto;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (['10', '11', '15'].indexOf(ie.substr(0, 2)) < 0) {
            return;
        }

        var algarismosPrincipais = ie.substr(0, 8);
        if (ie == '110944020' || ie == '110944021') {
            return true;
        }
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }
}

// MARANHAO
class ValidadorIEMA implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % 11;
        var digito = resto == 1 || resto == 0 ? 0 : 11 - resto;
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '12') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// MATO GROSSO
class ValidadorIEMT implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 9) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % 11;
        var digito = resto == 1 || resto == 0 ? 0 : 11 - resto;
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length < 2 || ie.length > 11) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}


// MATO GROSSO DO SUL
class ValidadorIEMS implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 9) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 0) {
            digito = modulo - resto;
            if (digito > 9) {
                digito = 0;
            }
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '28') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// MINAS GERAIS
class ValidadorIEMG implements IValidadorIE {
    ObterDigitoVerificador1(algarismosPrincipais: string): string {
        algarismosPrincipais = algarismosPrincipais.substr(0, 3) + '0' +
        algarismosPrincipais.substr(3);

        var somaAlg = '';
        for (var alg = 0, peso = 1; alg < algarismosPrincipais.length; alg++) {
            somaAlg += (parseInt(algarismosPrincipais.charAt(alg)) * peso).toString();
            peso = peso == 1 ? 2 : 1;
        }
        // Soma-se os algarismos (nao os produtos)
        var soma = 0;
        for (var i = 0; i < somaAlg.length; i++) {
            soma += parseInt(somaAlg.charAt(i));
        }

        //Subtrai-se o resultado da soma do item anterior, 
        //da primeira dezena exata imediatamente superior:
        var dezena = parseInt((soma + 10).toString().substr(0, 1) + '0');
        var digito = dezena - soma;
        return digito.toString();
    }

    ObterDigitoVerificador2(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 11) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 1) {
            digito = modulo - resto;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 13) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 2);
        var digito1 = this.ObterDigitoVerificador1(algarismosPrincipais);
        var digito2 = this.ObterDigitoVerificador2(algarismosPrincipais + digito1);
        var resultado = algarismosPrincipais + digito1 + digito2;

        var ok = resultado == ie;
        return ok;
    }
}


// PARA
class ValidadorIEPA implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {        
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {            
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 1) {
            digito = modulo - resto;            
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '15') {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// PARAIBA
class ValidadorIEPB implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        
        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// PARANA
class ValidadorIEPR implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 7) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 10) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 2);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var digito2 = this.ObterDigitoVerificador(algarismosPrincipais + digito1);
        var resultado = algarismosPrincipais + digito1 + digito2;

        var ok = resultado == ie;
        return ok;
    }
}


// PERNANBUCO
class ValidadorIEPE implements IValidadorIE {
    ObterDigitoVerificadorNovo(algarismosPrincipais: string): string {
        var soma = 0;
        for (var alg = 0, peso = algarismosPrincipais.length + 1; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % 11;

        var digito = resto == 1 || resto == 0 ? 0 : 11 - resto;
        return digito.toString();
    }

    ValidarNovo(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, 7);
        var digito1 = this.ObterDigitoVerificadorNovo(algarismosPrincipais);
        var digito2 = this.ObterDigitoVerificadorNovo(algarismosPrincipais + digito1);

        var resultado = algarismosPrincipais + digito1 + digito2;

        var ok = resultado == ie;
        return ok;
    }

    ObterDigitoVerificadorAntigo(algarismosPrincipais: string): string {
        var soma = 0;
        var pesoAlterado = false;
        for (var alg = 0, peso = 5; alg < algarismosPrincipais.length; alg++, peso--) {
            if (!pesoAlterado && peso < 1) {
                pesoAlterado = true;
                peso = 9;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }

        var resto = soma % 11;
        var digito = 11 - resto;
        if (digito > 9) {
            digito -= 10;
        }
        return digito.toString();
    }

    ValidarAntigo(ie: string): bool {
        if (ie.length != 14) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, 13);
        var digito = this.ObterDigitoVerificadorAntigo(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito;
        var ok = resultado == ie;
        return ok;
    }

    Validar(ie: string): bool {        
        if (ie.length == 9) {
            return this.ValidarNovo(ie);
        } else {
            return this.ValidarAntigo(ie);
        }
        return false;
    }
}

// PIAUI
class ValidadorIEPI implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {        
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {        
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);        
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// RIO DE JANEIRO
class ValidadorIERJ implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 7) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 1) {
            digito = modulo - resto;
        }        
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 8) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// RIO GRANDE DO NORTE
class ValidadorIERN implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {        
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        soma *= 10;
        var resto = soma % modulo;
        var digito = resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length < 9 || ie.length > 10) {
            return false;
        }
        if (ie.substr(0, 2) != '20') {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}


// RIO GRANDE DO SUL
class ValidadorIERS implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 9) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 10) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// RONDONIA
class ValidadorIERO implements IValidadorIE {    
    ObterDigitoVerificadorAntigo(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 6; alg < algarismosPrincipais.length; alg++, peso--) {        
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito -= 10;
        }
        return digito.toString();
    }

    ValidarAntigo(ie: string): boolean {
        var algarismosPrincipais = ie.substr(3, 5);
        var digito1 = this.ObterDigitoVerificadorAntigo(algarismosPrincipais);
        var resultado = ie.substr(0, 3) + algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }

    ObterDigitoVerificadorNovo(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 9) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito -= 10;
        }
        return digito.toString();
    }

    ValidarNovo(ie: string): boolean {
        var algarismosPrincipais = ie.substr(0, 13);
        var digito1 = this.ObterDigitoVerificadorNovo(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }

    Validar(ie: string): boolean {
        if (ie.length == 9) {
            return this.ValidarAntigo(ie);
        }
        if (ie.length == 14) {
            return this.ValidarNovo(ie);
        }
        return false;
    }
}



// RORAIMA
class ValidadorIERR implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {        
        var soma = 0;
        var modulo = 9;
        for (var alg = 0; alg < algarismosPrincipais.length; alg++) {        
            soma += parseInt(algarismosPrincipais.charAt(alg)) * (alg + 1);
        }
        var digito = soma % modulo;
        
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }
        if (ie.substr(0, 2) != '24') {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// SANTA CATARINA
class ValidadorIESC implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {        
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {        
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 1) {
            digito = modulo - resto;
        }        
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// SAO PAULO
class ValidadorIESP implements IValidadorIE {
    ObterDigitoVerificadorIndCom1(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 1; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso == 2) {
                peso = 3;
            } else if (peso == 9) {
                peso = 10;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = (soma % modulo).toString();
        var digito = resto.charAt(resto.length - 1);        
        return digito;
    }

    ObterDigitoVerificadorIndCom2(algarismosPrincipais: string): string {
        algarismosPrincipais = StringUtils.Reverse(algarismosPrincipais);
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 2; alg < algarismosPrincipais.length; alg++, peso++) {
            if (peso > 10) {
                peso = 2;
            }
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = (soma % modulo).toString();
        var digito = resto.charAt(resto.length - 1);
        return digito;
    }

    ObterDigitoVerificadorProdRural(algarismosPrincipais: string): string {
        return this.ObterDigitoVerificadorIndCom1(algarismosPrincipais);
    }

    ValidarIndCom(ie: string): boolean {
        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificadorIndCom1(algarismosPrincipais);
        algarismosPrincipais += digito1 + ie.substr(9, 2);
        var digito2 = this.ObterDigitoVerificadorIndCom2(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito2;
        var ok = resultado == ie;
        return ok;
    }



    ValidarProdRural(ie: string): boolean {
        var algarismosPrincipais = ie.substr(1, 8);
        var digito1 = this.ObterDigitoVerificadorProdRural(algarismosPrincipais);
        var resultado = 'P' + algarismosPrincipais + digito1 + ie.substr(10, 3);
        var ok = resultado == ie;
        return ok;
    }

    Validar(ie: string): boolean {
        if (ie.length == 12) {
            return this.ValidarIndCom(ie);
        }
        if (ie.length == 13 && ie.charAt(0) == 'P') {
            return this.ValidarProdRural(ie);
        }
        return false;        
    }
}

// SERGIPE
class ValidadorIESE implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = modulo - resto;
        if (digito > 9) {
            digito = 0;
        }
        return digito.toString();
    }

    Validar(ie: string): boolean {
        if (ie.length != 9) {
            return false;
        }

        var algarismosPrincipais = ie.substr(0, ie.length - 1);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;

        var ok = resultado == ie;
        return ok;
    }
}

// TOCANTINS
class ValidadorIETO implements IValidadorIE {
    ObterDigitoVerificador(algarismosPrincipais: string): string {
        var soma = 0;
        var modulo = 11;
        for (var alg = 0, peso = 9; alg < algarismosPrincipais.length; alg++, peso--) {
            soma += parseInt(algarismosPrincipais.charAt(alg)) * peso;
        }
        var resto = soma % modulo;
        var digito = 0;
        if (resto > 1) {
            digito = modulo - resto;
        }        
        return digito.toString();
    }


    ValidarAntigo(ie: string): boolean {        
        if (['01', '02', '03', '99'].indexOf(ie.substr(2, 2)) < 0) {
            return false;
        }
        var algarismosPrincipais = ie.substr(0, 2) + ie.substr(4, 6);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = ie.substr(0, ie.length - 1) + digito1;
        var ok = resultado == ie;
        return ok;
    }

    ValidarNovo(ie: string): boolean {
        var algarismosPrincipais = ie.substr(0, 8);
        var digito1 = this.ObterDigitoVerificador(algarismosPrincipais);
        var resultado = algarismosPrincipais + digito1;
        var ok = resultado == ie;
        return ok;
    }

    Validar(ie: string): boolean {
        if (ie.length == 11) {
            return this.ValidarAntigo(ie);
        }
        if (ie.length == 9) {
            return this.ValidarNovo(ie);
        }
        return false;        
    }
}
class ValidadorIE {
    Validar(estado: string, ieOriginal: string): boolean {
        var ie = StringUtils.RemoveMask(ieOriginal);
        estado = estado.toUpperCase();
        var validador: IValidadorIE;

        var resultado = false;
        switch (estado) {
            case 'PE':
                validador = new ValidadorIEPE();
                break;
            case 'AC':
                validador = new ValidadorIEAC();
                break;
            case 'AL':
                validador = new ValidadorIEAL();
                break;
            case 'AP':
                validador = new ValidadorIEAP();
                break;
            case 'AM':
                validador = new ValidadorIEAM();
                break;
            case 'BA':
                validador = new ValidadorIEBA();
                break;
            case 'CE':
                validador = new ValidadorIECE();
                break;
            case 'DF':
                validador = new ValidadorIEDF();
                break;
            case 'ES':
                validador = new ValidadorIEES();
                break;
            case 'GO':
                validador = new ValidadorIEGO();
                break;
            case 'MA':
                validador = new ValidadorIEMA();
                break;
            case 'MT':
                validador = new ValidadorIEMT();
                break;
            case 'MS':
                validador = new ValidadorIEMS();
                break;
            case 'MG':
                validador = new ValidadorIEMG();
                break;
            case 'PA':
                validador = new ValidadorIEPA();
                break;
            case 'PB':
                validador = new ValidadorIEPB();
                break;
            case 'PR':
                validador = new ValidadorIEPR();
                break;
            case 'PI':
                validador = new ValidadorIEPI();
                break;
            case 'RJ':
                validador = new ValidadorIERJ();
                break;
            case 'RN':
                validador = new ValidadorIERN();
                break;
            case 'RS':
                validador = new ValidadorIERS();
                break;
            case 'RO':
                validador = new ValidadorIERO();
                break;
            case 'RR':
                validador = new ValidadorIERR();
                break;
            case 'SC':
                validador = new ValidadorIESC();
                break;
            case 'SP':
                validador = new ValidadorIESP();
                break;
            case 'SE':
                validador = new ValidadorIESE();
                break;
            case 'TO':
                validador = new ValidadorIETO();
                break;
        }
        if (validador != undefined) {
            if (estado == 'SP' && ieOriginal.charAt(0).toUpperCase() == 'P') {
                ie = 'P' + ie;
            }
            resultado = validador.Validar(ie);
        }
        return resultado;
    }
}